Aminet 44/Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso/Aminet/comm/mail/YAM23src.lha/Source/YAM_rexx.h

C/C++ Source or Header | 2001-05-08 | 17KB | 981 lines

/***************************************************************************

 YAM - Yet Another Mailer
 Copyright (C) 1995-2000 by Marcel Beck <[e-mail]>
 Copyright (C) 2000-2001 by YAM Open Source Team

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 YAM Official Support Site :  http://www.yam.ch
 YAM OpenSource project    :  http://sourceforge.net/projects/yamos/

 $Id: YAM_rexx.h,v 1.3 2001/05/08 22:27:37 damato Exp $

***************************************************************************/
/*
 * Source generated with ARexxBox 1.12 (May 18 1993)
 * which is Copyright (c) 1992,1993 Michael Balzer
 */

#ifndef _YAM_rexx_H
#define _YAM_rexx_H

#define RXIF_INIT   1
#define RXIF_ACTION 2
#define RXIF_FREE   3

#define ARB_CF_ENABLED     (1L << 0)

#define ARB_HF_CMDSHELL    (1L << 0)
#define ARB_HF_USRMSGPORT  (1L << 1)

struct RexxHost
{
    struct MsgPort *port;
    char portname[ 80 ];
    long replies;
    struct RDArgs *rdargs;
    long flags;
    APTR userdata;
};

struct rxs_command
{
    char *command, *args, *results;
    long resindex;
    void (*function)( struct RexxHost *, void **, long, struct RexxMsg * );
    long flags;
};

struct arb_p_link
{
    char    *str;
    int        dst;
};

struct arb_p_state
{
    int        cmd;
    struct arb_p_link *pa;
};

#ifndef NO_GLOBALS
extern char RexxPortBaseName[80];
extern struct rxs_command rxs_commandlist[];
extern struct arb_p_state arb_p_state[];
extern int command_cnt;
extern char *rexx_extension;
#endif

void ReplyRexxCommand( struct RexxMsg *rxmsg, long prim, long sec, char *res );
void FreeRexxCommand( struct RexxMsg *rxmsg );
struct RexxMsg *CreateRexxCommand( struct RexxHost *host, char *buff, BPTR fh );
struct RexxMsg *CommandToRexx( struct RexxHost *host, struct RexxMsg *rexx_command_message );
struct RexxMsg *SendRexxCommand( struct RexxHost *host, char *buff, BPTR fh );

void CloseDownARexxHost( struct RexxHost *host );
struct RexxHost *SetupARexxHost( char *basename, struct MsgPort *usrport );
struct rxs_command *FindRXCommand( char *com );
char *ExpandRXCommand( struct RexxHost *host, char *command );
char *StrDup( char *s );
void ARexxDispatch( struct RexxHost *host );

/* rxd-Strukturen dürfen nur AM ENDE um lokale Variablen erweitert werden! */

struct rxd_addrdelete
{
    long rc, rc2;
    struct {
        char *alias;
    } arg;
};

void rx_addrdelete( struct RexxHost *, struct rxd_addrdelete **, long, struct RexxMsg * );

struct rxd_addredit
{
    long rc, rc2;
    struct {
        char *alias;
        char *name;
        char *email;
        char *pgp;
        char *homepage;
        char *street;
        char *city;
        char *country;
        char *phone;
        char *comment;
        long *birthdate;
        char *image;
        char **member;
        long add;
    } arg;
};

void rx_addredit( struct RexxHost *, struct rxd_addredit **, long, struct RexxMsg * );

struct rxd_addrfind
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *pattern;
        long nameonly;
        long emailonly;
    } arg;
    struct {
        char **alias;
    } res;
};

void rx_addrfind( struct RexxHost *, struct rxd_addrfind **, long, struct RexxMsg * );

struct rxd_addrgoto
{
    long rc, rc2;
    struct {
        char *alias;
    } arg;
};

void rx_addrgoto( struct RexxHost *, struct rxd_addrgoto **, long, struct RexxMsg * );

struct rxd_addrinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *alias;
    } arg;
    struct {
        char *type;
        char *name;
        char *email;
        char *pgp;
        char *homepage;
        char *street;
        char *city;
        char *country;
        char *phone;
        char *comment;
        long *birthdate;
        char *image;
        char **members;
    } res;
};

void rx_addrinfo( struct RexxHost *, struct rxd_addrinfo **, long, struct RexxMsg * );

struct rxd_addrload
{
    long rc, rc2;
    struct {
        char *filename;
    } arg;
};

void rx_addrload( struct RexxHost *, struct rxd_addrload **, long, struct RexxMsg * );

struct rxd_addrnew
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *type;
        char *alias;
        char *name;
        char *email;
    } arg;
    struct {
        char *alias;
    } res;
};

void rx_addrnew( struct RexxHost *, struct rxd_addrnew **, long, struct RexxMsg * );

struct rxd_addrresolve
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *alias;
    } arg;
    struct {
        char *recpt;
    } res;
};

void rx_addrresolve( struct RexxHost *, struct rxd_addrresolve **, long, struct RexxMsg * );

struct rxd_addrsave
{
    long rc, rc2;
    struct {
        char *filename;
    } arg;
};

void rx_addrsave( struct RexxHost *, struct rxd_addrsave **, long, struct RexxMsg * );

struct rxd_appbusy
{
    long rc, rc2;
    struct {
        char *text;
    } arg;
};

void rx_appbusy( struct RexxHost *, struct rxd_appbusy **, long, struct RexxMsg * );

struct rxd_appnobusy
{
    long rc, rc2;
};

void rx_appnobusy( struct RexxHost *, struct rxd_appnobusy **, long, struct RexxMsg * );

struct rxd_folderinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *folder;
    } arg;
    struct {
        long *number;
        char *name;
        char *path;
        long *total;
        long *new;
        long *unread;
        long *size;
        long *type;
    } res;
};

void rx_folderinfo( struct RexxHost *, struct rxd_folderinfo **, long, struct RexxMsg * );

struct rxd_getconfiginfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *item;
    } arg;
    struct {
        char *value;
    } res;
};

void rx_getconfiginfo( struct RexxHost *, struct rxd_getconfiginfo **, long, struct RexxMsg * );

struct rxd_getfolderinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *item;
    } arg;
    struct {
        char *value;
    } res;
};

void rx_getfolderinfo( struct RexxHost *, struct rxd_getfolderinfo **, long, struct RexxMsg * );

struct rxd_getmailinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *item;
    } arg;
    struct {
        char *value;
    } res;
};

void rx_getmailinfo( struct RexxHost *, struct rxd_getmailinfo **, long, struct RexxMsg * );

struct rxd_getselected
{
    long rc, rc2;
    struct {
        char *var, *stem;
    } arg;
    struct {
        long **num;
    } res;
};

void rx_getselected( struct RexxHost *, struct rxd_getselected **, long, struct RexxMsg * );

struct rxd_geturl
{
    long rc, rc2;
    struct {
        char *url;
        char *filename;
    } arg;
};

void rx_geturl( struct RexxHost *, struct rxd_geturl **, long, struct RexxMsg * );

struct rxd_help
{
    long rc, rc2;
    struct {
        char *file;
    } arg;
};

void rx_help( struct RexxHost *, struct rxd_help **, long, struct RexxMsg * );

struct rxd_hide
{
    long rc, rc2;
};

void rx_hide( struct RexxHost *, struct rxd_hide **, long, struct RexxMsg * );

struct rxd_info
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *item;
    } arg;
    struct {
        char *value;
    } res;
};

void rx_info( struct RexxHost *, struct rxd_info **, long, struct RexxMsg * );

struct rxd_isonline
{
    long rc, rc2;
};

void rx_isonline( struct RexxHost *, struct rxd_isonline **, long, struct RexxMsg * );

struct rxd_listselect
{
    long rc, rc2;
    struct {
        char *mode;
    } arg;
};

void rx_listselect( struct RexxHost *, struct rxd_listselect **, long, struct RexxMsg * );

struct rxd_mailarchive
{
    long rc, rc2;
    struct {
        char *folder;
    } arg;
};

void rx_mailarchive( struct RexxHost *, struct rxd_mailarchive **, long, struct RexxMsg * );

struct rxd_mailbounce
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailbounce( struct RexxHost *, struct rxd_mailbounce **, long, struct RexxMsg * );

struct rxd_mailchangesubject
{
    long rc, rc2;
    struct {
        char *subject;
    } arg;
};

void rx_mailchangesubject( struct RexxHost *, struct rxd_mailchangesubject **, long, struct RexxMsg * );

struct rxd_mailcheck
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long *pop;
        long manual;
    } arg;
    struct {
        long *downloaded;
        long *onserver;
        long *dupskipped;
        long *deleted;
    } res;
};

void rx_mailcheck( struct RexxHost *, struct rxd_mailcheck **, long, struct RexxMsg * );

struct rxd_mailcopy
{
    long rc, rc2;
    struct {
        char *folder;
    } arg;
};

void rx_mailcopy( struct RexxHost *, struct rxd_mailcopy **, long, struct RexxMsg * );

struct rxd_maildelete
{
    long rc, rc2;
    struct {
        long atonce;
        long force;
    } arg;
};

void rx_maildelete( struct RexxHost *, struct rxd_maildelete **, long, struct RexxMsg * );

struct rxd_mailedit
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailedit( struct RexxHost *, struct rxd_mailedit **, long, struct RexxMsg * );

struct rxd_mailexport
{
    long rc, rc2;
    struct {
        char *filename;
        long all;
        long append;
    } arg;
};

void rx_mailexport( struct RexxHost *, struct rxd_mailexport **, long, struct RexxMsg * );

struct rxd_mailfilter
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long all;
    } arg;
    struct {
        long *checked;
        long *bounced;
        long *forwarded;
        long *replied;
        long *executed;
        long *moved;
        long *deleted;
    } res;
};

void rx_mailfilter( struct RexxHost *, struct rxd_mailfilter **, long, struct RexxMsg * );

struct rxd_mailforward
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailforward( struct RexxHost *, struct rxd_mailforward **, long, struct RexxMsg * );

struct rxd_mailimport
{
    long rc, rc2;
    struct {
        char *filename;
        long wait;
    } arg;
};

void rx_mailimport( struct RexxHost *, struct rxd_mailimport **, long, struct RexxMsg * );

struct rxd_mailinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long *index;
    } arg;
    struct {
        long *index;
        char *status;
        char *from;
        char *to;
        char *replyto;
        char *subject;
        char *filename;
        long *size;
        char *date;
        char *flags;
        long *msgid;
    } res;
};

void rx_mailinfo( struct RexxHost *, struct rxd_mailinfo **, long, struct RexxMsg * );

struct rxd_mailmove
{
    long rc, rc2;
    struct {
        char *folder;
    } arg;
};

void rx_mailmove( struct RexxHost *, struct rxd_mailmove **, long, struct RexxMsg * );

struct rxd_mailread
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long *window;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailread( struct RexxHost *, struct rxd_mailread **, long, struct RexxMsg * );

struct rxd_mailreply
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailreply( struct RexxHost *, struct rxd_mailreply **, long, struct RexxMsg * );

struct rxd_mailsend
{
    long rc, rc2;
    struct {
        long all;
    } arg;
};

void rx_mailsend( struct RexxHost *, struct rxd_mailsend **, long, struct RexxMsg * );

struct rxd_mailsendall
{
    long rc, rc2;
};

void rx_mailsendall( struct RexxHost *, struct rxd_mailsendall **, long, struct RexxMsg * );

struct rxd_mailstatus
{
    long rc, rc2;
    struct {
        char *status;
    } arg;
};

void rx_mailstatus( struct RexxHost *, struct rxd_mailstatus **, long, struct RexxMsg * );

struct rxd_mailupdate
{
    long rc, rc2;
};

void rx_mailupdate( struct RexxHost *, struct rxd_mailupdate **, long, struct RexxMsg * );

struct rxd_mailwrite
{
    long rc, rc2;
    struct {
        char *var, *stem;
        long *window;
        long quiet;
    } arg;
    struct {
        long *window;
    } res;
};

void rx_mailwrite( struct RexxHost *, struct rxd_mailwrite **, long, struct RexxMsg * );

struct rxd_newmailfile
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *folder;
    } arg;
    struct {
        char *filename;
    } res;
};

void rx_newmailfile( struct RexxHost *, struct rxd_newmailfile **, long, struct RexxMsg * );

struct rxd_quit
{
    long rc, rc2;
    struct {
        long force;
    } arg;
};

void rx_quit( struct RexxHost *, struct rxd_quit **, long, struct RexxMsg * );

struct rxd_readclose
{
    long rc, rc2;
};

void rx_readclose( struct RexxHost *, struct rxd_readclose **, long, struct RexxMsg * );

struct rxd_readinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
    } arg;
    struct {
        char **filename;
        char **filetype;
        long **filesize;
        char **tempfile;
    } res;
};

void rx_readinfo( struct RexxHost *, struct rxd_readinfo **, long, struct RexxMsg * );

struct rxd_readprint
{
    long rc, rc2;
    struct {
        long *part;
    } arg;
};

void rx_readprint( struct RexxHost *, struct rxd_readprint **, long, struct RexxMsg * );

struct rxd_readsave
{
    long rc, rc2;
    struct {
        long *part;
        char *filename;
        long overwrite;
    } arg;
};

void rx_readsave( struct RexxHost *, struct rxd_readsave **, long, struct RexxMsg * );

struct rxd_request
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *body;
        char *gadgets;
    } arg;
    struct {
        long *result;
    } res;
};

void rx_request( struct RexxHost *, struct rxd_request **, long, struct RexxMsg * );

struct rxd_requestfolder
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *body;
        long excludeactive;
    } arg;
    struct {
        char *folder;
    } res;
};

void rx_requestfolder( struct RexxHost *, struct rxd_requestfolder **, long, struct RexxMsg * );

struct rxd_requeststring
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *body;
        char *string;
        long secret;
    } arg;
    struct {
        char *string;
    } res;
};

void rx_requeststring( struct RexxHost *, struct rxd_requeststring **, long, struct RexxMsg * );

struct rxd_screentoback
{
    long rc, rc2;
};

void rx_screentoback( struct RexxHost *, struct rxd_screentoback **, long, struct RexxMsg * );

struct rxd_screentofront
{
    long rc, rc2;
};

void rx_screentofront( struct RexxHost *, struct rxd_screentofront **, long, struct RexxMsg * );

struct rxd_setflag
{
    long rc, rc2;
    struct {
        long *vol;
        long *per;
    } arg;
};

void rx_setflag( struct RexxHost *, struct rxd_setflag **, long, struct RexxMsg * );

struct rxd_setfolder
{
    long rc, rc2;
    struct {
        char *folder;
    } arg;
};

void rx_setfolder( struct RexxHost *, struct rxd_setfolder **, long, struct RexxMsg * );

struct rxd_setmail
{
    long rc, rc2;
    struct {
        long *num;
    } arg;
};

void rx_setmail( struct RexxHost *, struct rxd_setmail **, long, struct RexxMsg * );

struct rxd_setmailfile
{
    long rc, rc2;
    struct {
        char *mailfile;
    } arg;
};

void rx_setmailfile( struct RexxHost *, struct rxd_setmailfile **, long, struct RexxMsg * );

struct rxd_show
{
    long rc, rc2;
};

void rx_show( struct RexxHost *, struct rxd_show **, long, struct RexxMsg * );

struct rxd_userinfo
{
    long rc, rc2;
    struct {
        char *var, *stem;
    } arg;
    struct {
        char *username;
        char *email;
        char *realname;
        char *config;
        char *maildir;
        long *folders;
    } res;
};

void rx_userinfo( struct RexxHost *, struct rxd_userinfo **, long, struct RexxMsg * );

struct rxd_writeattach
{
    long rc, rc2;
    struct {
        char *file;
        char *desc;
        char *encmode;
        char *ctype;
    } arg;
};

void rx_writeattach( struct RexxHost *, struct rxd_writeattach **, long, struct RexxMsg * );

struct rxd_writebcc
{
    long rc, rc2;
    struct {
        char **address;
        long add;
    } arg;
};

void rx_writebcc( struct RexxHost *, struct rxd_writebcc **, long, struct RexxMsg * );

struct rxd_writecc
{
    long rc, rc2;
    struct {
        char **address;
        long add;
    } arg;
};

void rx_writecc( struct RexxHost *, struct rxd_writecc **, long, struct RexxMsg * );

struct rxd_writeeditor
{
    long rc, rc2;
    struct {
        char *var, *stem;
        char *command;
    } arg;
    struct {
        char *result;
    } res;
};

void rx_writeeditor( struct RexxHost *, struct rxd_writeeditor **, long, struct RexxMsg * );

struct rxd_writefrom
{
    long rc, rc2;
    struct {
        char *address;
    } arg;
};

void rx_writefrom( struct RexxHost *, struct rxd_writefrom **, long, struct RexxMsg * );

struct rxd_writeletter
{
    long rc, rc2;
    struct {
        char *file;
        long nosig;
    } arg;
};

void rx_writeletter( struct RexxHost *, struct rxd_writeletter **, long, struct RexxMsg * );

struct rxd_writemailto
{
    long rc, rc2;
    struct {
        char **address;
    } arg;
};

void rx_writemailto( struct RexxHost *, struct rxd_writemailto **, long, struct RexxMsg * );

struct rxd_writeoptions
{
    long rc, rc2;
    struct {
        long delete;
        long receipt;
        long notif;
        long addinfo;
        long *importance;
        long *sig;
        long *security;
    } arg;
};

void rx_writeoptions( struct RexxHost *, struct rxd_writeoptions **, long, struct RexxMsg * );

struct rxd_writequeue
{
    long rc, rc2;
    struct {
        long hold;
    } arg;
};

void rx_writequeue( struct RexxHost *, struct rxd_writequeue **, long, struct RexxMsg * );

struct rxd_writereplyto
{
    long rc, rc2;
    struct {
        char *address;
    } arg;
};

void rx_writereplyto( struct RexxHost *, struct rxd_writereplyto **, long, struct RexxMsg * );

struct rxd_writesend
{
    long rc, rc2;
};

void rx_writesend( struct RexxHost *, struct rxd_writesend **, long, struct RexxMsg * );

struct rxd_writesubject
{
    long rc, rc2;
    struct {
        char *subject;
    } arg;
};

void rx_writesubject( struct RexxHost *, struct rxd_writesubject **, long, struct RexxMsg * );

struct rxd_writeto
{
    long rc, rc2;
    struct {
        char **address;
        long add;
    } arg;
};

void rx_writeto( struct RexxHost *, struct rxd_writeto **, long, struct RexxMsg * );

#endif